package edu.server.servicio;

import java.text.DecimalFormat;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

import edu.client.ComprasService.ComprasService;
import edu.server.dominio.Administrador;
import edu.server.dominio.Almacen;
import edu.server.dominio.Compras;
import edu.server.dominio.D_Empleado;
import edu.server.dominio.D_Inventario;
import edu.server.dominio.D_ModoEnvio;
import edu.server.dominio.D_OrdenCompraProducto;
import edu.server.dominio.D_Producto;
import edu.server.dominio.D_Proveedor;
import edu.server.dominio.D_ProveedorDeProducto;
import edu.server.dominio.D_RequerimientoAdicionalCompra;
import edu.server.dominio.D_RequerimientoCompra;
import edu.server.dominio.Estado;
import edu.server.dominio.Insumos;
import edu.server.dominio.ModoDeEnvio;
import edu.server.repositorio.Categoria;
import edu.server.repositorio.Contacto;
import edu.server.repositorio.Direccion;
import edu.server.repositorio.EstadoOrden;
import edu.server.repositorio.IngresoInsumos;
import edu.server.repositorio.Insumo;
import edu.server.repositorio.Inventario;
import edu.server.repositorio.Localidad;
import edu.server.repositorio.Marca;
import edu.server.repositorio.MedidasVariablesEstandar;
import edu.server.repositorio.ModoEnvio;
import edu.server.repositorio.OrdenCompraInsumo;
import edu.server.repositorio.OrdenCompraProducto;
import edu.server.repositorio.Pais;
import edu.server.repositorio.Producto;
import edu.server.repositorio.Proveedor;
import edu.server.repositorio.ProveedorDeInsumo;
import edu.server.repositorio.ProveedorDeInsumoId;
import edu.server.repositorio.ProveedorDeProducto;
import edu.server.repositorio.ProveedorDeProductoId;
import edu.server.repositorio.Provincia;
import edu.server.repositorio.RenglonIngresoInsumos;
import edu.server.repositorio.RenglonOrdenCompraInsumo;
import edu.server.repositorio.RenglonOrdenCompraInsumoId;
import edu.server.repositorio.RenglonOrdenCompraProducto;
import edu.server.repositorio.RequerimientoAdicionalesCompra;
import edu.server.repositorio.RequerimientoCompra;
import edu.shared.DTO.ContactoDTO;
import edu.shared.DTO.DireccionDTO;
import edu.shared.DTO.ElementoProductoDTO;
import edu.shared.DTO.InsumoCantidad;
import edu.shared.DTO.InsumoDTO;
import edu.shared.DTO.MaterialProductoDTO;
import edu.shared.DTO.MedidaFijaProductoDTO;
import edu.shared.DTO.MedidaVariableEstandarDTO;
import edu.shared.DTO.ModoEnvioDTO;
import edu.shared.DTO.OrdenCompraInsumoDTO;
import edu.shared.DTO.OrdenCompraProductoDTO;
import edu.shared.DTO.ProductoDTO;
import edu.shared.DTO.ProveedorDTO;
import edu.shared.DTO.ProveedorDeInsumosDTO;
import edu.shared.DTO.ProveedorDeProductoDTO;
import edu.shared.DTO.RenglonOrdenCompraInsumoDTO;
import edu.shared.DTO.RenglonOrdenCompraProductoDTO;
import edu.shared.DTO.RequerimientoAdicionalCompraDTO;
import edu.shared.DTO.RequerimientoCompraDTO;

public class ComprasServiceImpl extends RemoteServiceServlet implements ComprasService {

	/**
	 * 
	 */
	private static final long serialVersionUID = -5338747283996853109L;

	
	//------------------------------------Orden de compra de productos------------------------------------------
	
	/**
	 * Método que busca las órdenes de compra de producto con un estado particular
	 */
	@Override
	public List<OrdenCompraProductoDTO> buscarOrdenesCompraProducto(String estado) {
		
		List<OrdenCompraProductoDTO> ordenesDTO = new LinkedList<OrdenCompraProductoDTO>();
		List<OrdenCompraProducto> ordenes;
		Compras compras = new Compras();
		
		//buscamos las órdenes de compra en la base de datos
		ordenes = compras.buscarOrdenesCompraProducto(estado);
		
		//cargamos la orden de compra DTO
		for(int i=0; i<ordenes.size(); i++)
		{
			OrdenCompraProducto orden = ordenes.get(i);
			OrdenCompraProductoDTO ordenDTO = new OrdenCompraProductoDTO();
			
			ordenDTO.setIdOrden(orden.getIdOrdenCompra());
			ordenDTO.setProveedor(orden.getProveedor().getNombre());
			ordenDTO.setFechaGeneracion(orden.getFechaGeneracion());
			
			ordenesDTO.add(ordenDTO);
		}
		
		return ordenesDTO;
	}
	
	
	/**
	 * Método que busca las órdenes de compra de producto completas, con todos sus datos
	 */
	public OrdenCompraProductoDTO buscarOrdenCompraProductoCompleta(int idOrdenCompraProducto) throws Exception
	{
		D_OrdenCompraProducto ordenCompraDominio = new D_OrdenCompraProducto();
		OrdenCompraProducto orden;
		OrdenCompraProductoDTO ordenDTO = new OrdenCompraProductoDTO();
		
		orden = ordenCompraDominio.buscarOrdenCompraProductoCompleta(idOrdenCompraProducto);
		
		//cargamos el objeto DTO
		ordenDTO.setIdOrden(orden.getIdOrdenCompra());
		ordenDTO.setProveedor(orden.getProveedor().getNombre());
		ordenDTO.setFechaGeneracion(orden.getFechaGeneracion());
		ordenDTO.setUltimaFechaEdicion(orden.getUltimaFechaModificacion());
		ordenDTO.setModoEnvio(orden.getModoEnvio().getDescripcion());
		ordenDTO.setFormaPago(orden.getFormaPago());
		ordenDTO.setIva(orden.getIva());
		ordenDTO.setObservaciones(orden.getObservaciones());
		
		
		D_RequerimientoCompra requerimientoCompraDominio = new D_RequerimientoCompra();
		D_RequerimientoAdicionalCompra requerimientoAdicionalDominio = new D_RequerimientoAdicionalCompra();
		
		//buscamos los renglones de la orden de compra de producto
		List<RenglonOrdenCompraProducto> renglones = ordenCompraDominio.buscarRenglones(orden.getIdOrdenCompra());
		Set<RenglonOrdenCompraProductoDTO> renglonesDTO = new HashSet<RenglonOrdenCompraProductoDTO>(); 
		
		for(RenglonOrdenCompraProducto renglon : renglones)
		{
			RenglonOrdenCompraProductoDTO renglonDTO = new RenglonOrdenCompraProductoDTO();
			
			renglonDTO.setIdRenglon(renglon.getIdRenglonOrdenCompraProducto());
			renglonDTO.setCantidadAComprar(renglon.getCantidadAComprar());
			
			List<RequerimientoCompra> requerimientos = requerimientoCompraDominio.buscarPorRenglonOrdenCompra(renglonDTO.getIdRenglon());
			Producto producto;
			double medidaVariable1;
			double medidaVariable2;
			
			//si el renglón se relaciona con un requerimiento de compra
			if(requerimientos.size() > 0)
			{
				//recuperamos el producto del requerimiento y se lo seteamos al renglon de la orden de compra
				producto = requerimientos.get(0).getRequerimientoMateriales().getProducto();
				
				//calculamos la cantidad requerida
				int cantidadRequerida = requerimientos.get(0).getCantidadRequerida();
	
				if(requerimientos.size() > 1)
				{
					//si hay requerimientos integrados, se suma la cantidad requerida para éste
					for(int j=1; j<requerimientos.size(); j++)
						cantidadRequerida = cantidadRequerida + requerimientos.get(j).getCantidadRequerida();
				}
				
				renglonDTO.setCantidadRequerida(cantidadRequerida);
				
				medidaVariable1 = requerimientos.get(0).getMedidaVariable1();
				medidaVariable2 = requerimientos.get(0).getMedidaVariable2();
				
				//indicamos que el renglón no es de un producto adicional
				renglonDTO.setEsAdicional(false);
			}
			
			//si el renglón se relaciona con un producto adicional
			else
			{
				//buscamos el requerimiento adicional relacionado al renglón
				RequerimientoAdicionalesCompra requerimientoAdicional = requerimientoAdicionalDominio.buscarPorRenglonOrdenCompra(renglonDTO.getIdRenglon());
			
				if(requerimientoAdicional == null)
					throw new Exception("No existe el requerimiento adicional.");
				
				//recuperamos el producto del requerimiento adicional
				producto = requerimientoAdicional.getProducto();
				
				medidaVariable1 = requerimientoAdicional.getMedidaVariable1();
				medidaVariable2 = requerimientoAdicional.getMedidaVariable2();
				
				//indicamos que el renglón se relaciona con un producto adicional
				renglonDTO.setEsAdicional(true);
			}
			
			ProductoDTO productoDTO = new ProductoDTO();
			
			productoDTO.setIdProducto(producto.getIdProducto());
			productoDTO.getElemento().setNombre(producto.getElementoProducto().getNombre());
			productoDTO.getMaterial().setNombre(producto.getMaterialProducto().getNombre());
			productoDTO.getMedidaFija().setMedida(producto.getMedidaFijaProducto().getMedida());
			productoDTO.setMedidaVariable1(medidaVariable1);
			productoDTO.setMedidaVariable2(medidaVariable2);
			
			//asignamos el producto al renglón
			renglonDTO.setProducto(productoDTO);
			
			//agregamos el renglón a la lista de renglones de la orden de compra
			renglonesDTO.add(renglonDTO);
		}
				
		//agregamos los renglones a la orden de compra
		ordenDTO.setRenglones(renglonesDTO);
			
		return ordenDTO;
	}
	
	/**
	 * Método que valida las órdenes de compra de productos con los id pasados como parámetro
	 */
	public Boolean validarOrdenesCompraProducto(List<Integer> idOrdenesCompraProducto)	
	{
		D_OrdenCompraProducto ordenCompraDominio = new D_OrdenCompraProducto();		
		ordenCompraDominio.cambiarEstadoOrdenCompraProducto(idOrdenesCompraProducto, "VALIDADA");
		
		D_RequerimientoCompra requerimientoCompraDominio = new D_RequerimientoCompra();
		
		//por cada orden de compra a validar
		for(int idOrden : idOrdenesCompraProducto){
			//buscamos los renglones de la orden
			List<RenglonOrdenCompraProducto> renglones = ordenCompraDominio.buscarRenglones(idOrden);
			
			//por cada renglón, seteamos el bit activo a falso
			for(RenglonOrdenCompraProducto renglon : renglones)
			{
				requerimientoCompraDominio.setActivo(renglon.getIdRenglonOrdenCompraProducto(), false);
				
				//buscamos los requerimientos de compra del renglon
				List<RequerimientoCompra> requerimientos = requerimientoCompraDominio.buscarPorRenglonOrdenCompra(renglon.getIdRenglonOrdenCompraProducto());
				
				//si el renglón contenía un requerimiento de compra
				if(requerimientos.size() > 0)
				{
					//por cada producto del renglón, y si la cantidad comprada > cantidad requerida, actualizamos el valor
					//de cantidad disponible pendiente de entrega en el inventario del producto
					for(RequerimientoCompra requerimiento : requerimientos)
					{
						int idProducto = requerimiento.getRequerimientoMateriales().getProducto().getIdProducto();
						String medida1 = String.valueOf(requerimiento.getMedidaVariable1());
						String medida2 = String.valueOf(requerimiento.getMedidaVariable2());
						
						//calculamos la cantidad disponible pendiente de entrega
						float cantidadRequerida = requerimiento.getCantidadRequerida();
						float cantidadAComprar = renglon.getCantidadAComprar();
						
						double cantidadDisponiblePendienteEntrega = cantidadAComprar - cantidadRequerida;
		
						//si hay productos disponibles pendientes
						if(cantidadDisponiblePendienteEntrega > 0)
							actualizarCantidadDisponibleProducto(idProducto, medida1, medida2, 0, cantidadDisponiblePendienteEntrega);
					}
				}
				
				//si el renglón contenía requerimientos adicionales de compra
				else
				{
					//buscamos los requerimientos adicionales de compra del renglon
					D_RequerimientoAdicionalCompra adicionalDominio = new D_RequerimientoAdicionalCompra();

					RequerimientoAdicionalesCompra requerimientoAdicional = adicionalDominio.buscarPorRenglonOrdenCompra(renglon.getIdRenglonOrdenCompraProducto());
					
					int idProducto = requerimientoAdicional.getProducto().getIdProducto();
					String medida1 = String.valueOf(requerimientoAdicional.getMedidaVariable1());
					String medida2 = String.valueOf(requerimientoAdicional.getMedidaVariable2());
					
					//la cantidad disponible de entrega es igual a la cantidad a comprar para los requerimientos adicionales
					double cantidadDisponiblePendienteEntrega = renglon.getCantidadAComprar();

					actualizarCantidadDisponibleProducto(idProducto, medida1, medida2, 0, cantidadDisponiblePendienteEntrega);
					
				}
			}
		}
		
		return true;
	}
	
	
	private void actualizarCantidadDisponibleProducto(int idProducto, String medida1, String medida2, double cantidadDisponible, double cantidadDisponiblePendienteEntrega)
	{
		D_Inventario inventarioDominio = new D_Inventario();

		//buscamos el inventario del producto en la base de datos
		Inventario inventario = inventarioDominio.buscarPorProducto(idProducto, medida1, medida2);
		
		//si no existe el inventario para el producto, lo creamos
		if(inventario == null)
		{
			//buscamos el producto
			D_Producto productoDominio = new D_Producto();
			Producto producto = productoDominio.buscarProducto(idProducto);
			
			//creamos el inventario con los valores pasados como parámetro
			inventario = new Inventario();
			
			inventario.setMedida1(medida1);
			inventario.setMedida2(medida2);
			inventario.setProducto(producto);
			inventario.setCantidadDisponible(cantidadDisponible);
			inventario.setCantDisponiblePendienteEntrega(0);
		}
		
		//seteamos la cantidad disponible pendiente de entrega
		inventario.setCantDisponiblePendienteEntrega(inventario.getCantDisponiblePendienteEntrega() + cantidadDisponiblePendienteEntrega);
		
		//guardamos el inventario en la base de datos
		inventarioDominio.registrar(inventario);
	}
	
	/**
	 * Método que cancela las órdenes de compra de productos con los id pasados como parámetro
	 */
	public Boolean cancelarOrdenesCompraProducto(List<Integer> idOrdenesCompraProducto)	
	{
		D_OrdenCompraProducto ordenCompraDominio = new D_OrdenCompraProducto();
		ordenCompraDominio.cambiarEstadoOrdenCompraProducto(idOrdenesCompraProducto, "CANCELADA");
		
		D_RequerimientoCompra requerimientoCompraDominio = new D_RequerimientoCompra();
		
		for(int idOrden : idOrdenesCompraProducto)
		{
			//buscamos los renglones de la orden
			List<RenglonOrdenCompraProducto> renglones = ordenCompraDominio.buscarRenglones(idOrden);
			
			//por cada renglón, seteamos el bit activo a true
			for(RenglonOrdenCompraProducto renglon : renglones)
			{
				requerimientoCompraDominio.setActivo(renglon.getIdRenglonOrdenCompraProducto(), true);
				requerimientoCompraDominio.desvincularRenglonOrdenCompraProducto(renglon.getIdRenglonOrdenCompraProducto());
			}
			
			//eliminamos los renglones de la orden de compra
			ordenCompraDominio.eliminarRenglones(idOrden);		
		}
		return true;
	}
	
	/**
	 * Método que busca todos los proveedores
	 */
	public List<String> buscarNombresProveedores()
	{
		D_Proveedor proveedoresDominio = new D_Proveedor();
		List<String> proveedores;
		
		//buscamos los nombres de los proveedores en la base de datos
		proveedores = proveedoresDominio.buscarNombresProveedores();
		
		return proveedores;
	}
	
	/**
	 * Método que busca todos los productos
	 */
	public List<ProductoDTO> buscarProductos(){
		
		D_Producto productosDominio = new D_Producto();
		List<Producto> productos;
		List<ProductoDTO> productosDTO = new LinkedList<ProductoDTO>();
		
		productos = productosDominio.buscarProductos();
		
		//cargamos los datos en productosDTO
		for(Producto producto : productos)
		{
			ProductoDTO productoDTO = new ProductoDTO();
			ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
			MaterialProductoDTO materialDTO = new MaterialProductoDTO();
			MedidaFijaProductoDTO medidaFijaDTO = new MedidaFijaProductoDTO();
			
			productoDTO.setIdProducto(producto.getIdProducto());
		
			//seteamos los valores al elemento del producto y se lo asignamos al producto
			elementoDTO.setCodigo(producto.getElementoProducto().getId().getCodigoElementoProducto());
			elementoDTO.setNombre(producto.getElementoProducto().getNombre());
			elementoDTO.setTipoDimension(producto.getElementoProducto().getTipoDimension());

			productoDTO.setElemento(elementoDTO);
			
			//seteamos los valores del material del producto y se lo seteamos al producto
			materialDTO.setCodigo(producto.getMaterialProducto().getCodigoMaterialProducto());
			materialDTO.setNombre(producto.getMaterialProducto().getNombre());
			
			productoDTO.setMaterial(materialDTO);
			
			//seteamos los valores de la medida fija del producto
			medidaFijaDTO.setCodigo(producto.getMedidaFijaProducto().getCodigoMedidaFijaProducto());
			medidaFijaDTO.setMedida(producto.getMedidaFijaProducto().getMedida());
			
			productoDTO.setMedidaFija(medidaFijaDTO);
			
			productoDTO.setActivo(producto.isActivo());
			
			
			//cargamos las medidas estándares del producto
			Set<MedidasVariablesEstandar> medidasEstandar = producto.getMedidasVariablesEstandars();
			
			for(MedidasVariablesEstandar medidaEstandar : medidasEstandar)
			{
				MedidaVariableEstandarDTO medida = new MedidaVariableEstandarDTO();			
				
				float medidaEstandar1 = (float) medidaEstandar.getId().getMedidaVariable1();
				float medidaEstandar2 = (float) medidaEstandar.getId().getMedidaVariable2();
				
				medida.setMedidaVariable1(medidaEstandar1);
				medida.setMedidaVariable2(medidaEstandar2);
				
				productoDTO.getMedidasEstandar().add(medida);
			}
			
			//agregamos el producto a la lista de productos
			productosDTO.add(productoDTO);
		}
		
		return productosDTO;
	}
	
	/**
	 * Método que busca en la base de datos todos los productos que son provisto por un determinado proveedor.
	 */
	public List<ProductoDTO> buscarProductosProvistos(String nombreProveedor)
	{
		D_Proveedor proveedoresDominio = new D_Proveedor();
		List<Producto> productos;
		List<ProductoDTO> productosDTO = new LinkedList<ProductoDTO>();
		Proveedor proveedor;
		
		if(!nombreProveedor.equals("< TODOS >"))
			//buscamos el proveedor
			proveedor = proveedoresDominio.getProveedorPorNombre(nombreProveedor);
		
		else
			proveedor = null;
		
		//buscamos los productos provistos por el proveedor
		productos = proveedoresDominio.buscarProductosProvistos(proveedor);
		
		for(Producto producto : productos)
		{
			ProductoDTO productoDTO = new ProductoDTO();
			ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
			MaterialProductoDTO materialDTO = new MaterialProductoDTO();
			
			productoDTO.setIdProducto(producto.getIdProducto());
			
			//seteamos los valores al elemento del producto y se lo asignamos al producto
			elementoDTO.setCodigo(producto.getElementoProducto().getId().getCodigoElementoProducto());
			elementoDTO.setNombre(producto.getElementoProducto().getNombre());
			elementoDTO.setTipoDimension(producto.getElementoProducto().getTipoDimension());
			
			productoDTO.setElemento(elementoDTO);
			
			//seteamos los valores del material del producto y se lo seteamos al producto
			materialDTO.setCodigo(producto.getMaterialProducto().getCodigoMaterialProducto());
			materialDTO.setNombre(producto.getMaterialProducto().getNombre());
			
			productoDTO.setMaterial(materialDTO);
			
			//seteamos los valores de la medida fija del producto
			MedidaFijaProductoDTO medidaFijaDTO = new MedidaFijaProductoDTO();
			medidaFijaDTO.setCodigo(producto.getMedidaFijaProducto().getCodigoMedidaFijaProducto());
			medidaFijaDTO.setMedida(producto.getMedidaFijaProducto().getMedida());	
			
			productoDTO.setMedidaFija(medidaFijaDTO);
			
			productoDTO.setActivo(producto.isActivo());
			
			
			//cargamos las medidas estándares del producto
			Set<MedidasVariablesEstandar> medidasEstandar = producto.getMedidasVariablesEstandars();
			
			for(MedidasVariablesEstandar medidaEstandar : medidasEstandar)
			{
				MedidaVariableEstandarDTO medida = new MedidaVariableEstandarDTO();			
				
				float medidaEstandar1 = (float) medidaEstandar.getId().getMedidaVariable1();
				float medidaEstandar2 = (float) medidaEstandar.getId().getMedidaVariable2();
				
				medida.setMedidaVariable1(medidaEstandar1);
				medida.setMedidaVariable2(medidaEstandar2);
				
				productoDTO.getMedidasEstandar().add(medida);
			}
			
			
			//agregamos el producto a la lista de productos
			productosDTO.add(productoDTO);
		}
		
		return productosDTO;
	}
	
	/**
	 * Método que busca en la base de datos todos los requerimientos de compra que pueden ser provistos por un determinado proveedor.
	 */
	public List<RequerimientoCompraDTO> buscarRequerimientosCompra(String nombreProveedor)
	{
		Proveedor proveedor;
		D_Proveedor proveedorDominio = new D_Proveedor();
		
		if(!nombreProveedor.equals("< TODOS >"))
			//buscamos el proveedor en la base de datos
			proveedor = proveedorDominio.getProveedorPorNombre(nombreProveedor);
		
		else
			proveedor = null;
		
		List<RequerimientoCompra> requerimientosCompra;
		List<RequerimientoCompraDTO> requerimientosCompraDTO = new LinkedList<RequerimientoCompraDTO>();
		D_RequerimientoCompra requerimientoCompraDominio = new D_RequerimientoCompra();
		
		requerimientosCompra = requerimientoCompraDominio.buscarPorProveedor(proveedor);	
		
		for(RequerimientoCompra requerimiento : requerimientosCompra)
		{
			RequerimientoCompraDTO requerimientoDTO = new RequerimientoCompraDTO();
			
			requerimientoDTO.setIdRequerimientoCompra(requerimiento.getIdRequerimientoCompra());
			
			requerimientoDTO.setMedidaVariable1(requerimiento.getMedidaVariable1());
			requerimientoDTO.setCantidadRequerida(requerimiento.getCantidadRequerida());
			requerimientoDTO.setFechaRequerimientoCompra(requerimiento.getFechaRequerimientoCompra());
			
			if(requerimiento.getMedidaVariable2() != null)	
				requerimientoDTO.setMedidaVariable2(requerimiento.getMedidaVariable2());
			
			else
				requerimientoDTO.setMedidaVariable2(Double.parseDouble(String.valueOf(0)));
			
			//cargamos el producto de la orden de compra del requerimiento de compra
			//recuperamos el producto del requerimiento de material
			Producto producto = requerimiento.getRequerimientoMateriales().getProducto();
			
			ProductoDTO productoDTO = new ProductoDTO();
			ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
			MaterialProductoDTO materialDTO = new MaterialProductoDTO();
			
			productoDTO.setIdProducto(producto.getIdProducto());
			
			//seteamos los valores al elemento del producto y se lo asignamos al producto
			elementoDTO.setCodigo(producto.getElementoProducto().getId().getCodigoElementoProducto());
			elementoDTO.setNombre(producto.getElementoProducto().getNombre());
			elementoDTO.setTipoDimension(producto.getElementoProducto().getTipoDimension());
			
			productoDTO.setElemento(elementoDTO);
			
			//seteamos los valores del material del producto y se lo seteamos al producto
			materialDTO.setCodigo(producto.getMaterialProducto().getCodigoMaterialProducto());
			materialDTO.setNombre(producto.getMaterialProducto().getNombre());
			
			productoDTO.setMaterial(materialDTO);
			
			//seteamos los valores de la medida fija del producto
			MedidaFijaProductoDTO medidaFijaDTO = new MedidaFijaProductoDTO();
			medidaFijaDTO.setCodigo(producto.getMedidaFijaProducto().getCodigoMedidaFijaProducto());
			medidaFijaDTO.setMedida(producto.getMedidaFijaProducto().getMedida());	
			
			productoDTO.setMedidaFija(medidaFijaDTO);
			productoDTO.setActivo(producto.isActivo());
			
			//seteamos el producto al requerimiento del material del requerimiento de compra
			requerimientoDTO.getRequerimientoMaterial().setProducto(productoDTO);
			
			requerimientosCompraDTO.add(requerimientoDTO);
		}
		
		return requerimientosCompraDTO;
	}
	
	/**
	 * Método que busca en la base de datos todos los modos de envío cargados.
	 */
	public List<ModoEnvioDTO> buscarModosEnvio()
	{
		List<ModoEnvio> modosEnvio;
		List<ModoEnvioDTO> modosEnvioDTO = new LinkedList<ModoEnvioDTO>();
		D_ModoEnvio modoEnvioDominio = new D_ModoEnvio();
		
		//buscamos todos los modos de envío en la base de datos
		modosEnvio = modoEnvioDominio.buscarTodos();
		
		//cargamos los objetos DTOs
		for(ModoEnvio modoEnvio : modosEnvio)
		{
			ModoEnvioDTO modoEnvioDTO = new ModoEnvioDTO();
			
			modoEnvioDTO.setIdModoEnvio(modoEnvio.getIdModoEnvio());
			modoEnvioDTO.setDescripcion(modoEnvio.getDescripcion());
			
			modosEnvioDTO.add(modoEnvioDTO);
		}
		
		return modosEnvioDTO;
	}
	
	/**
	 * Método que busca los precios de una lista de productos para un proveedor particular.
	 */
	public List<Double> buscarPrecios(String nombreProveedor, List<Integer> idProductos)
	{
		D_Proveedor proveedorDominio = new D_Proveedor();
		Proveedor proveedor = proveedorDominio.getProveedorPorNombre(nombreProveedor);
		
		D_ProveedorDeProducto proveedorProductoDominio = new D_ProveedorDeProducto();
		List<Double> precios = new LinkedList<Double>();
		
		//para cada producto, buscamos su precio y lo agregamos a la lista de precios.
		for(int idProducto : idProductos)
		{
			double precio = proveedorProductoDominio.buscarPrecio(proveedor.getCodigoProveedor(), idProducto);
			
			precios.add(precio);
		}
		
		return precios;
	}
	
	
	/**
	 * Método que registra en la base de datos los nuevos precios cargados
	 * @return Boolean. True si la operación fue exitosa.
	 */
	public Boolean registrarPrecios(List<ProveedorDeProductoDTO> proveedoresDeProducto)
	{
		D_ProveedorDeProducto proveedorDeProductoDominio = new D_ProveedorDeProducto();
		
		D_Proveedor proveedorDominio = new D_Proveedor();
		Proveedor proveedor = proveedorDominio.getProveedorPorNombre(proveedoresDeProducto.get(0).getProveedor().getNombre());
		
		for(ProveedorDeProductoDTO proveedorDeProductoDTO : proveedoresDeProducto){
			
			//generamos el id del proveedor del producto
			ProveedorDeProductoId id = new ProveedorDeProductoId();
			
			id.setIdProducto(proveedorDeProductoDTO.getProducto().getIdProducto());
			id.setIdProveedor(proveedor.getCodigoProveedor());
			
			//buscamos el proveedor de producto que tiene el id recientemente generado
			ProveedorDeProducto proveedorDeProducto = proveedorDeProductoDominio.buscarProveedorDeProducto(id);
			
			//actualizamos su precio
			proveedorDeProducto.setPrecio(proveedorDeProductoDTO.getPrecio());
			
			//actializamos la entidad en la base de datos
			proveedorDeProductoDominio.registrarProveedorDeProducto(proveedorDeProducto);
		}
		
		return true;
	}
	
	
	/**
	 * Método que guarda en la base de datos una orden de compra de producto y sus renglones.
	 */
	public Integer registrarOrdenCompraProducto(OrdenCompraProductoDTO ordenCompraDTO, List<RenglonOrdenCompraProductoDTO> renglonesDTO, List<RequerimientoAdicionalCompraDTO> requerimientosAdicionales)
	{
		//buscamos el proveedor
		D_Proveedor proveedorDominio = new D_Proveedor();
		Proveedor proveedor = proveedorDominio.getProveedorPorNombre(ordenCompraDTO.getProveedor());
		
		//buscamos el modo de envío
		D_ModoEnvio modoEnvioDominio = new D_ModoEnvio();
		ModoEnvio modoEnvio = null;
		
		if(ordenCompraDTO.getModoEnvio() != null)
			modoEnvio = modoEnvioDominio.buscarPorDescripcion(ordenCompraDTO.getModoEnvio());
		
		
		
		//creamos la orden de compra de producto
		OrdenCompraProducto ordenCompra = new OrdenCompraProducto();
		
		ordenCompra.setIdOrdenCompra(ordenCompraDTO.getIdOrden());
		ordenCompra.setProveedor(proveedor);
		ordenCompra.setModoEnvio(modoEnvio);
		ordenCompra.setFechaGeneracion(ordenCompraDTO.getFechaGeneracion());
		ordenCompra.setUltimaFechaModificacion(ordenCompraDTO.getUltimaFechaEdicion());
		ordenCompra.setIva(ordenCompraDTO.getIva());
		ordenCompra.setFormaPago(ordenCompraDTO.getFormaPago().toUpperCase());
		ordenCompra.setObservaciones(ordenCompraDTO.getObservaciones());
		ordenCompra.setEstado(ordenCompraDTO.getEstado());
		
		//registramos la orden de compra
		D_OrdenCompraProducto ordenCompraDominio = new D_OrdenCompraProducto();
		ordenCompraDominio.registrar(ordenCompra);
		
		//registramos los renglones de la orden de compra
		List<RenglonOrdenCompraProducto> renglones = new LinkedList<RenglonOrdenCompraProducto>();
		
		for(RenglonOrdenCompraProductoDTO renglonDTO : renglonesDTO)
		{
			RenglonOrdenCompraProducto renglon = new RenglonOrdenCompraProducto();
			
			renglon.setIdRenglonOrdenCompraProducto(renglonDTO.getIdRenglon());
			renglon.setOrdenCompraProducto(ordenCompra);
			renglon.setCantidadAComprar(renglonDTO.getCantidadAComprar());
			
			renglones.add(renglon);
		}
		
		ordenCompraDominio.registrarRenglones(renglones);
		
		//si no se está editando una orden de compra de producto
		if(requerimientosAdicionales != null)
		{
			//creamos los requerimientos adicionales
			int desplazamiento = renglonesDTO.size() - requerimientosAdicionales.size();
			int i = 0;
			
			D_Producto productoDominio = new D_Producto();
			
			List<RequerimientoAdicionalesCompra> requerimientos = new LinkedList<RequerimientoAdicionalesCompra>();
			
			for(RequerimientoAdicionalCompraDTO requerimientoDTO : requerimientosAdicionales)
			{
				RequerimientoAdicionalesCompra requerimiento = new RequerimientoAdicionalesCompra();
				
				Producto producto = productoDominio.buscarProducto(requerimientoDTO.getProducto().getIdProducto());
				RenglonOrdenCompraProducto renglonOrdenCompraProducto = ordenCompraDominio.buscarRenglon(renglones.get(i + desplazamiento).getIdRenglonOrdenCompraProducto());
						
				requerimiento.setRenglonOrdenCompraProducto(renglonOrdenCompraProducto);
				requerimiento.setProducto(producto);
				requerimiento.setMedidaVariable1(requerimientoDTO.getMedidaVariable1());
				requerimiento.setMedidaVariable2(requerimientoDTO.getMedidaVariable2());
				
				requerimientos.add(requerimiento);
				
				i++;
			}
			
			D_RequerimientoAdicionalCompra requerimientoDominio = new D_RequerimientoAdicionalCompra();
			
			//registramos los requerimientos adicionales de compra
			requerimientoDominio.registrar(requerimientos);
		}
		
		return ordenCompra.getIdOrdenCompra();
	}
	
	
	/**
	 * Método que le asigna la orden de compra a un requerimiento de compra.
	 */
	public Boolean actualizarRequierimientosCompra(List<List<Integer>> idRequerimientos, int idOrdenCompra) throws Exception
	{
		D_OrdenCompraProducto ordenCompraDominio = new D_OrdenCompraProducto();
		List<RenglonOrdenCompraProducto> renglones = ordenCompraDominio.buscarRenglones(idOrdenCompra);
		
		if(renglones != null){
			D_RequerimientoCompra requerimientoCompraDominio = new D_RequerimientoCompra();
			requerimientoCompraDominio.asignarRenglonOrdenCompraProducto(idRequerimientos, renglones);
		}
		
		return true;
	}
	
	
	/**
	 * Método que busca en la base de datos las órdes de compra de producto filtradas por proveedor
	 */
	public List<OrdenCompraProductoDTO> buscarOrdenesCompraProductoPorProveedor(String proveedor, String estado)
	{
		List<OrdenCompraProducto> ordenes;
		List<OrdenCompraProductoDTO> ordenesDTO = new LinkedList<OrdenCompraProductoDTO>(); 
		D_OrdenCompraProducto ordenCompraDominio = new D_OrdenCompraProducto();
		
		//buscamos las ordenes de compra de producto filtradas por el proveedor
		ordenes = ordenCompraDominio.buscarPorProveedor(proveedor, estado);
		
		//cargamos los datos de las órdenes de compra de producto
		for(OrdenCompraProducto orden : ordenes)
		{
			OrdenCompraProductoDTO ordenDTO = new OrdenCompraProductoDTO();
			
			ordenDTO.setIdOrden(orden.getIdOrdenCompra());
			ordenDTO.setFechaGeneracion(orden.getFechaGeneracion());
			ordenDTO.setProveedor(orden.getProveedor().getNombre());
			ordenDTO.setEstado(orden.getEstado());
			
			ordenesDTO.add(ordenDTO);
		}
		
		return ordenesDTO;
	}			
	
	//------------------------------------Orden de compra de insumos------------------------------------------
	
	@Override
	public Boolean registrarNuevoProveedor(ProveedorDTO proveedor) throws IllegalArgumentException {
		Pais pais = new Pais();
		Provincia provincia = new Provincia();
		Localidad local = new Localidad();
		Direccion domicilio = new Direccion();
		Proveedor nuevo = new Proveedor();
		pais.setNombre(proveedor.getDireccion().getPais().toUpperCase());
		provincia.setNombre(proveedor.getDireccion().getProvincia().toUpperCase());
		local.setNombre(proveedor.getDireccion().getLocalidad().toUpperCase());
		local.setCodigoPostal(proveedor.getDireccion().getCodigoLocalidad());
		provincia.setPais(pais);
		local.setProvincia(provincia);

		domicilio.setCalle(proveedor.getDireccion().getCalle());
		domicilio.setAltura(proveedor.getDireccion().getAltura());
		domicilio.setPiso(proveedor.getDireccion().getPiso());
		domicilio.setOficina(proveedor.getDireccion().getOficina());
		domicilio.setCpa(proveedor.getDireccion().getCpa());
		domicilio.setLocalidad(local);

		nuevo.setNombre(proveedor.getNombre());
		nuevo.setCuit(proveedor.getCuit());
		nuevo.setResponsable(proveedor.getResponsable());
		nuevo.setRubro(proveedor.getRubro());
		nuevo.setFax(proveedor.getFax());
		nuevo.setTelefono(proveedor.getTelefono());
		nuevo.setPaginaWeb(proveedor.getPaginaWeb());
		nuevo.setMail(proveedor.getMail());
		nuevo.setObservaciones(proveedor.getObservaciones());
		nuevo.setTipoProveedor(proveedor.getTipoProveedor());
		nuevo.setDireccion(domicilio);
		if (proveedor.getContacto().size() > 0) {
			for (ContactoDTO contacto : proveedor.getContacto()) {
				Contacto nuevoCont = new Contacto();
				nuevoCont.setCargo(contacto.getCargo());
				nuevoCont.setCelular(contacto.getCelular());
				nuevoCont.setInternoEmpresa(contacto.getInternoEmpresa());
				nuevoCont.setMail(contacto.getMail());
				nuevoCont.setNombre(contacto.getNombre());
				nuevoCont.setTelefonoEmpresa(contacto.getTelefonoEmpresa());
				nuevoCont.setTelefonoParticular(contacto.getTelefonoParticular());
				nuevoCont.setProveedor(nuevo);
				nuevo.getContactos().add(nuevoCont);
			}
		}
		Compras adminCompras = new Compras();
		return adminCompras.registrarProveedor(nuevo);

	}

	@Override
	public Boolean registrarCambioProveedor(ProveedorDTO proveedor) throws IllegalArgumentException {
		Pais pais = new Pais();
		Provincia provincia = new Provincia();
		Localidad local = new Localidad();
		Direccion domicilio = new Direccion();
		Proveedor nuevo = new Proveedor();
		pais.setNombre(proveedor.getDireccion().getPais().toUpperCase());
		provincia.setNombre(proveedor.getDireccion().getProvincia().toUpperCase());
		local.setNombre(proveedor.getDireccion().getLocalidad().toUpperCase());
		local.setCodigoPostal(proveedor.getDireccion().getCodigoLocalidad());
		provincia.setPais(pais);
		local.setProvincia(provincia);

		domicilio.setCalle(proveedor.getDireccion().getCalle());
		domicilio.setAltura(proveedor.getDireccion().getAltura());
		domicilio.setPiso(proveedor.getDireccion().getPiso());
		domicilio.setOficina(proveedor.getDireccion().getOficina());
		domicilio.setCpa(proveedor.getDireccion().getCpa());
		domicilio.setLocalidad(local);

		nuevo.setNombre(proveedor.getNombre());
		nuevo.setCuit(proveedor.getCuit());
		nuevo.setResponsable(proveedor.getResponsable());
		nuevo.setRubro(proveedor.getRubro());
		nuevo.setFax(proveedor.getFax());
		nuevo.setTelefono(proveedor.getTelefono());
		nuevo.setPaginaWeb(proveedor.getPaginaWeb());
		nuevo.setMail(proveedor.getMail());
		nuevo.setObservaciones(proveedor.getObservaciones());
		nuevo.setTipoProveedor(proveedor.getTipoProveedor());
		nuevo.setDireccion(domicilio);
		if (proveedor.getContacto().size() > 0) {
			for (ContactoDTO contacto : proveedor.getContacto()) {
				Contacto nuevoCont = new Contacto();
				nuevoCont.setCargo(contacto.getCargo());
				nuevoCont.setCelular(contacto.getCelular());
				nuevoCont.setInternoEmpresa(contacto.getInternoEmpresa());
				nuevoCont.setMail(contacto.getMail());
				nuevoCont.setNombre(contacto.getNombre());
				nuevoCont.setTelefonoEmpresa(contacto.getTelefonoEmpresa());
				nuevoCont.setTelefonoParticular(contacto.getTelefonoParticular());
				nuevoCont.setProveedor(nuevo);
				nuevo.getContactos().add(nuevoCont);
			}
		}
		Compras adminCompras = new Compras();
		return adminCompras.registrarCambiosProveedor(nuevo);
	}

	@Override
	public ProveedorDTO getEmpresaCompleta(String nombre) throws IllegalArgumentException {

		Proveedor busqueda = new Proveedor();

		D_Proveedor adminProv = new D_Proveedor();

		busqueda = adminProv.getEmpresaCompleta(nombre);

		ProveedorDTO result = new ProveedorDTO();

		DireccionDTO dire = new DireccionDTO();

		dire.setCalle(busqueda.getDireccion().getCalle());
		dire.setAltura(busqueda.getDireccion().getAltura());
		dire.setOficina(busqueda.getDireccion().getOficina());
		dire.setPiso(busqueda.getDireccion().getPiso());
		dire.setCpa(busqueda.getDireccion().getCpa());
		dire.setLocalidad(busqueda.getDireccion().getLocalidad().getNombre());
		dire.setProvincia(busqueda.getDireccion().getLocalidad().getProvincia().getNombre());
		dire.setPais(busqueda.getDireccion().getLocalidad().getProvincia().getPais().getNombre());
		dire.setCodigoLocalidad(busqueda.getDireccion().getLocalidad().getCodigoPostal());

		result.setNombre(busqueda.getNombre());
		result.setCuit(busqueda.getCuit());
		result.setRubro(busqueda.getRubro());
		result.setResponsable(busqueda.getResponsable());
		result.setTelefono(busqueda.getTelefono());
		result.setFax(busqueda.getFax());
		result.setMail(busqueda.getMail());
		result.setPaginaWeb(busqueda.getPaginaWeb());
		result.setObservaciones(busqueda.getObservaciones());
		result.setTipoProveedor(busqueda.getTipoProveedor());
		result.setDireccion(dire);

		for (Contacto contacto : busqueda.getContactos()) {

			ContactoDTO nuevo = new ContactoDTO();
			nuevo.setNombre(contacto.getNombre());
			nuevo.setCargo(contacto.getCargo());
			nuevo.setCelular(contacto.getCelular());
			nuevo.setMail(contacto.getMail());
			nuevo.setTelefonoEmpresa(contacto.getTelefonoEmpresa());
			nuevo.setTelefonoParticular(contacto.getTelefonoParticular());
			nuevo.setInternoEmpresa(contacto.getInternoEmpresa());

			result.getContacto().add(nuevo);

		}

		return result;

	}

	@Override
	public List<String> getNombresEmpresas() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getNombresEmpresas();

	}

	@Override
	public List<String> getRubros() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getRubros();

	}

	@Override
	public List<String> getTipos() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getTipos();

	}

	@Override
	public List<String> getContactos() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getContactos();

	}

	@Override
	public List<ContactoDTO> getEmpresasPorContacto(String nombre) throws IllegalArgumentException {

		List<ContactoDTO> result = new LinkedList<ContactoDTO>();
		D_Proveedor adminProv = new D_Proveedor();
		List<Contacto> busqueda = adminProv.getEmpresasPorContacto(nombre);

		for (Contacto contacto : busqueda) {

			String[] rubroYempresa = adminProv.getEmpresaRubroPorIdProveedor(contacto.getProveedor().getCodigoProveedor());

			ContactoDTO nuevo = new ContactoDTO();
			ProveedorDTO nuevoProveedor = new ProveedorDTO();
			nuevoProveedor.setNombre(rubroYempresa[0]);
			nuevoProveedor.setRubro(rubroYempresa[1]);
			nuevo.setNombre(contacto.getNombre());
			nuevo.setCargo(contacto.getCargo());
			nuevo.setProveedor(nuevoProveedor);

			result.add(nuevo);

		}

		return result;

	}

	@Override
	public ContactoDTO getContactoCompleto(String nombreContacto, String nombreEmpresa) throws IllegalArgumentException {

		Contacto contacto;

		D_Proveedor adminProv = new D_Proveedor();
		contacto = adminProv.getContactoCompleto(nombreContacto, nombreEmpresa);

		ContactoDTO nuevo = new ContactoDTO();
		nuevo.setNombre(contacto.getNombre());
		nuevo.setCargo(contacto.getCargo());
		nuevo.setCelular(contacto.getCelular());
		nuevo.setMail(contacto.getMail());
		nuevo.setTelefonoEmpresa(contacto.getTelefonoEmpresa());
		nuevo.setTelefonoParticular(contacto.getTelefonoParticular());
		nuevo.setInternoEmpresa(contacto.getInternoEmpresa());

		return nuevo;

	}

	@Override
	public Boolean eliminarContacto(String nombreEmpresa, String nombreContacto) throws IllegalArgumentException {

		Compras adminCompras = new Compras();

		return adminCompras.eliminarContacto(nombreEmpresa, nombreContacto);

	}

	@Override
	public List<ProveedorDTO> getEmpresasPorRubro(String nombre) throws IllegalArgumentException {

		List<ProveedorDTO> result = new LinkedList<ProveedorDTO>();
		D_Proveedor adminProv = new D_Proveedor();
		List<Proveedor> busqueda = adminProv.getEmpresasPorRubro(nombre);

		for (Proveedor proveedor : busqueda) {

			ProveedorDTO nuevo = new ProveedorDTO();
			nuevo.setNombre(proveedor.getNombre());
			nuevo.setRubro(proveedor.getRubro());
			nuevo.setTelefono(proveedor.getTelefono());
			nuevo.setMail(proveedor.getMail());

			result.add(nuevo);

		}

		return result;

	}

	@Override
	public List<ProveedorDTO> getEmpresasPorTipo(String nombre) throws IllegalArgumentException {

		List<ProveedorDTO> result = new LinkedList<ProveedorDTO>();
		D_Proveedor adminProv = new D_Proveedor();
		List<Proveedor> busqueda = adminProv.getEmpresasPorTipo(nombre);

		for (Proveedor proveedor : busqueda) {

			ProveedorDTO nuevo = new ProveedorDTO();
			nuevo.setNombre(proveedor.getNombre());
			nuevo.setRubro(proveedor.getRubro());
			nuevo.setTelefono(proveedor.getTelefono());
			nuevo.setMail(proveedor.getMail());

			result.add(nuevo);

		}

		return result;

	}

	@Override
	public Boolean eliminarEmpresa(String nombreEmpresa) throws IllegalArgumentException {

		Compras adminCompras = new Compras();

		return adminCompras.eliminarEmpresa(nombreEmpresa);

	}

	@Override
	public List<ProveedorDTO> getEmpresas(String nombre) throws IllegalArgumentException {

		List<ProveedorDTO> result = new LinkedList<ProveedorDTO>();
		D_Proveedor adminProv = new D_Proveedor();
		List<Proveedor> busqueda = adminProv.getEmpresas(nombre);

		for (Proveedor proveedor : busqueda) {

			ProveedorDTO nuevo = new ProveedorDTO();
			nuevo.setNombre(proveedor.getNombre());
			nuevo.setRubro(proveedor.getRubro());
			nuevo.setTelefono(proveedor.getTelefono());
			nuevo.setMail(proveedor.getMail());

			result.add(nuevo);

		}

		return result;

	}

	@Override
	public List<ProveedorDTO> getEmpresas() throws IllegalArgumentException {

		List<ProveedorDTO> result = new LinkedList<ProveedorDTO>();
		D_Proveedor adminProv = new D_Proveedor();
		List<Proveedor> busqueda = adminProv.getEmpresas();

		for (Proveedor proveedor : busqueda) {

			ProveedorDTO nuevo = new ProveedorDTO();
			nuevo.setNombre(proveedor.getNombre());
			nuevo.setRubro(proveedor.getRubro());
			nuevo.setTelefono(proveedor.getTelefono());
			nuevo.setMail(proveedor.getMail());

			result.add(nuevo);

		}

		return result;

	}

	@Override
	public int retornaIdContacto(String nombreEmpresa, String nombreContacto) throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();
		return adminProv.retornaIdContacto(nombreEmpresa, nombreContacto);

	}

	@Override
	public Boolean modificarContacto(ContactoDTO contacto, int idContacto) throws IllegalArgumentException {

		Contacto nuevoCont = new Contacto();
		Compras adminCompras = new Compras();
		D_Proveedor adminProv = new D_Proveedor();
		Proveedor proveedor = adminProv.getEmpresaCompleta(contacto.getProveedor().getNombre());

		nuevoCont.setIdContacto(idContacto);
		nuevoCont.setCargo(contacto.getCargo());
		nuevoCont.setCelular(contacto.getCelular());
		nuevoCont.setInternoEmpresa(contacto.getInternoEmpresa());
		nuevoCont.setMail(contacto.getMail());
		nuevoCont.setNombre(contacto.getNombre());
		nuevoCont.setTelefonoEmpresa(contacto.getTelefonoEmpresa());
		nuevoCont.setTelefonoParticular(contacto.getTelefonoParticular());
		nuevoCont.setProveedor(null);
		nuevoCont.setProveedor(proveedor);

		return adminCompras.registrarCambiosContacto(nuevoCont);

	}

	@Override
	public Boolean registrarNuevoInsumo(InsumoDTO insumo) throws IllegalArgumentException {

		Compras adminCompras = new Compras();
		D_Proveedor adminProv = new D_Proveedor();

		Marca marca = new Marca();
		marca.setNombre(insumo.getMarca());

		Categoria categoria = new Categoria();
		categoria.setNombre(insumo.getCategoria());

		Insumo nuevo = new Insumo();
		nuevo.setCategoria(categoria);
		nuevo.setMarca(marca);
		nuevo.setNombre(insumo.getNombre());
		nuevo.setLoteCompra(insumo.getLoteCompra());
		nuevo.setStockSeguridad(insumo.getStockSeguridad());
		nuevo.setObservaciones(insumo.getObservaciones());
		nuevo.setNecesidadCompra(true);

		if (insumo.getProveedor().size() > 0) {

			for (ProveedorDeInsumosDTO proveedor : insumo.getProveedor()) {
				ProveedorDeInsumoId idPI = new ProveedorDeInsumoId();
				Proveedor buscar = adminProv.getProveedorPorNombre(proveedor.getNombre());
				idPI.setIdProveedor(buscar.getCodigoProveedor());
				ProveedorDeInsumo nuevoProv = new ProveedorDeInsumo();
				nuevoProv.setProveedor(buscar);
				nuevoProv.setId(idPI);
				nuevoProv.setInsumo(nuevo);
				nuevoProv.setObservaciones(proveedor.getObservaciones());
				
				if(proveedor.getPrecio() != null){
					nuevoProv.setPrecio(proveedor.getPrecio());
				}
				else{
					nuevoProv.setPrecio(null);
				}
				nuevo.getProveedorDeInsumos().add(nuevoProv);

			}
		}

		if(adminCompras.registrarInsumo(nuevo)){
			Insumos adminInsumos = new Insumos();
			int idInsumo = adminInsumos.getIdInsumo(nuevo.getNombre(), nuevo.getMarca().getNombre());
			return adminInsumos.setNecesidadCompraEnUno(idInsumo);
			
		}
		else{
			return false;
		}
		

	}

	@Override
	public Boolean registrarCambioInsumo(InsumoDTO insumo) throws IllegalArgumentException {

		Compras adminCompras = new Compras();
		D_Proveedor adminProv = new D_Proveedor();
		Insumos adminInsumo = new Insumos();

		Marca marca = new Marca();
		marca.setNombre(insumo.getMarca());

		int idMarca = adminInsumo.marcaExistente(marca.getNombre());
		marca.setIdMarca(idMarca);

		Categoria categoria = new Categoria();
		categoria.setNombre(insumo.getCategoria());

		int idCategoria = adminInsumo.categoriaExistente(categoria.getNombre());
		categoria.setIdCategoria(idCategoria);

		Insumo nuevo = new Insumo();
		nuevo.setIdInsumo(insumo.getIdInsumo());
		nuevo.setCategoria(categoria);
		nuevo.setMarca(marca);
		nuevo.setNombre(insumo.getNombre());
		nuevo.setLoteCompra(insumo.getLoteCompra());
		nuevo.setStockSeguridad(insumo.getStockSeguridad());
		nuevo.setObservaciones(insumo.getObservaciones());
		nuevo.setCantidad(insumo.getCantidad());
		if(nuevo.getStockSeguridad()>nuevo.getCantidad())
			nuevo.setNecesidadCompra(true);
		else
			nuevo.setNecesidadCompra(false);
		
		//nuevo.setNecesidadCompra(insumo.isNecesidadCompra());
		

		if (insumo.getProveedor().size() > 0) {

			for (ProveedorDeInsumosDTO proveedor : insumo.getProveedor()) {
				ProveedorDeInsumoId idPI = new ProveedorDeInsumoId();
				Proveedor buscar = adminProv.getProveedorPorNombre(proveedor.getNombre());
				idPI.setIdProveedor(buscar.getCodigoProveedor());
				ProveedorDeInsumo nuevoProv = new ProveedorDeInsumo();
				nuevoProv.setProveedor(buscar);
				nuevoProv.setId(idPI);
				nuevoProv.setInsumo(nuevo);
				nuevoProv.setObservaciones(proveedor.getObservaciones());
				if(proveedor.getPrecio() != null){
					
					nuevoProv.setPrecio(proveedor.getPrecio());
				}
				else{
					nuevoProv.setPrecio(null);
				}
					

				nuevo.getProveedorDeInsumos().add(nuevoProv);

			}
		}

		return adminCompras.registrarCambioInsumo(nuevo);

	}

	@Override
	public List<String> getNombresInsumos(String letra) throws IllegalArgumentException {

		Insumos adminInsumo = new Insumos();

		return adminInsumo.getNombresInsumos(letra);

	}

	@Override
	public List<String> getNombresMarcas() throws IllegalArgumentException {

		Insumos adminInsumo = new Insumos();

		return adminInsumo.getNombresMarcas();

	}

	@Override
	public List<String> getNombresCategorias() throws IllegalArgumentException {

		Insumos adminInsumo = new Insumos();

		return adminInsumo.getNombresCategorias();

	}

	@Override
	public List<String> getNombresProveedoresInsumo() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getNombresProveedoresInsumo();

	}

	@Override
	public List<InsumoDTO> getInsumosSegunParametro(String tipo, String dato) throws IllegalArgumentException {

		Insumos adminInsumo = new Insumos();

		List<InsumoDTO> listResult = new LinkedList<InsumoDTO>();
		List<Insumo> result = new LinkedList<Insumo>();

		result = adminInsumo.getInsumosSegunParametro(tipo, dato);

		for (Insumo insumo : result) {

			InsumoDTO nuevo = new InsumoDTO();
			nuevo.setNombre(insumo.getNombre());
			nuevo.setCategoria(insumo.getCategoria().getNombre());
			nuevo.setMarca(insumo.getMarca().getNombre());
			nuevo.setIdInsumo(insumo.getIdInsumo());

			listResult.add(nuevo);
		}
		return listResult;

	}

	@Override
	public InsumoDTO getInsumoCompleto(int idInsumo, String nombreInsumo) throws IllegalArgumentException {

		InsumoDTO result = new InsumoDTO();
		Insumo insumo = new Insumo();
		Insumos adminInsumos = new Insumos();

		insumo = adminInsumos.getInsumoCompleto(idInsumo, nombreInsumo);

		result.setIdInsumo(insumo.getIdInsumo());
		result.setNombre(insumo.getNombre());
		result.setLoteCompra(insumo.getLoteCompra());
		result.setStockSeguridad(insumo.getStockSeguridad());
		result.setObservaciones(insumo.getObservaciones());
		
		result.setNecesidadCompra(insumo.isNecesidadCompra());
		
		if (insumo.getCantidad() != -1 && insumo.getCantidad() != 0) {
			result.setCantidad(insumo.getCantidad());
		} else {
			result.setCantidad(0);
		}
		result.setMarca(insumo.getMarca().getNombre());
		result.setCategoria(insumo.getCategoria().getNombre());

		for (ProveedorDeInsumo prov : insumo.getProveedorDeInsumos()) {

			ProveedorDeInsumosDTO proveedor = new ProveedorDeInsumosDTO();

			if(prov.getPrecio() == null)
				proveedor.setPrecio();
			else{
				Double precio = Double.parseDouble(prov.getPrecio().toString());
				proveedor.setPrecio(precio);
			}

			proveedor.setNombre(prov.getProveedor().getNombre());
			proveedor.setObservaciones(prov.getObservaciones());

			result.getProveedor().add(proveedor);

		}

		return result;
	}
	
	@Override
	public InsumoDTO getInsumoCompleto(String nombre, String marca) throws IllegalArgumentException {

		InsumoDTO result = new InsumoDTO();
		Insumo insumo = new Insumo();
		Insumos adminInsumos = new Insumos();
		int idInsumo = adminInsumos.getIdInsumo(nombre, marca);

		insumo = adminInsumos.getInsumoCompleto(idInsumo, nombre);
		
		result.setIdInsumo(insumo.getIdInsumo());
		result.setNombre(insumo.getNombre());
		result.setLoteCompra(insumo.getLoteCompra());
		result.setStockSeguridad(insumo.getStockSeguridad());
		result.setObservaciones(insumo.getObservaciones());
		
		result.setNecesidadCompra(insumo.isNecesidadCompra());
		
		if (insumo.getCantidad() != -1 && insumo.getCantidad() != 0) {
			result.setCantidad(insumo.getCantidad());
		} else {
			result.setCantidad(0);
		}
		result.setMarca(insumo.getMarca().getNombre());
		result.setCategoria(insumo.getCategoria().getNombre());

		for (ProveedorDeInsumo prov : insumo.getProveedorDeInsumos()) {

			ProveedorDeInsumosDTO proveedor = new ProveedorDeInsumosDTO();

			if(prov.getPrecio() == null)
				proveedor.setPrecio();
			else{
				Double precio = Double.parseDouble(prov.getPrecio().toString());
				proveedor.setPrecio(precio);
			}

			proveedor.setNombre(prov.getProveedor().getNombre());
			proveedor.setObservaciones(prov.getObservaciones());

			result.getProveedor().add(proveedor);

		}

		return result;
	}
	
	@Override
	public Boolean getExistenciaInsumo(String nombreInsumo, String marcaInsumo) throws IllegalArgumentException {
		
		Insumos adminInsumos = new Insumos();
		return adminInsumos.getExistenciaInsumo(nombreInsumo, marcaInsumo);
		
	}

	@Override
	public Boolean eliminarInsumo(InsumoDTO insumo) throws IllegalArgumentException {

		Insumo nuevo = new Insumo();
		nuevo.setIdInsumo(insumo.getIdInsumo());
		Compras adminCompras = new Compras();
		return adminCompras.eliminarInsumo(nuevo);

	}

	@Override
	public List<String> getNombresMarcasSegunInsumo(String nombreInsumo) throws IllegalArgumentException {

		Insumos adminInsumos = new Insumos();

		return adminInsumos.getNombresMarcasSegunInsumo(nombreInsumo);
	}

	@Override
	public List<String> getNombresProvSegunInsumoYMarca(String nombreInsumo, String nombreMarca) throws IllegalArgumentException {

		Insumos adminInsumo = new Insumos();

		return adminInsumo.getNombresProvSegunInsumoYMarca(nombreInsumo, nombreMarca);
	}

	@Override
	public List<InsumoDTO> getRequerimientosInsumosCompletos() throws IllegalArgumentException {

		Insumos admniInsumos = new Insumos();

		List<Object> idInsumos = admniInsumos.getRequerimientosNecesario();
		List<InsumoDTO> result = new LinkedList<InsumoDTO>();

		for (Object id : idInsumos) {
			InsumoDTO agrega = new InsumoDTO();
			agrega = this.getInsumoCompleto((int) id, "");
			result.add(agrega);
		}

		return result;

	}

	@Override
	public List<InsumoDTO> completarValoresInsumos(List<InsumoDTO> insumos, String proveedor) throws IllegalArgumentException {
		Insumos adminInsumos = new Insumos();
		D_Proveedor adminProv = new D_Proveedor();
		for (InsumoDTO insumo : insumos) {
			Insumo insuAux = new Insumo();
			int idInsumo = adminInsumos.getIdInsumo(insumo.getNombre(), insumo.getMarca());
			int idProv = adminProv.getProveedorPorNombre(proveedor).getCodigoProveedor();
			insumo.setIdInsumo(idInsumo);

			insuAux = adminInsumos.getInsumoCompleto(insumo.getIdInsumo(), "");
			insumo.setCantidad(insuAux.getCantidad());
			insumo.setLoteCompra(insuAux.getLoteCompra());

			for (ProveedorDeInsumo prov : insuAux.getProveedorDeInsumos()) {
				if (prov.getId().getIdProveedor() == idProv) {
					ProveedorDeInsumosDTO proveedorInsu = new ProveedorDeInsumosDTO();
					proveedorInsu.setPrecio(prov.getPrecio());
					insumo.getProveedor().add(proveedorInsu);
				}
			}
		}

		return insumos;
	}

	@Override
	public List<String> getModoDeEnvio() throws IllegalArgumentException {
		ModoDeEnvio adminME = new ModoDeEnvio();
		return adminME.getModoDeEnvio();
	}

	@Override
	public boolean registrarOrdenCompraInsumos(OrdenCompraInsumoDTO orden,String tipoUsuario) throws IllegalArgumentException {
		
		OrdenCompraInsumo nueva = new OrdenCompraInsumo();
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		D_Empleado adEmpleado = new D_Empleado();
		ModoDeEnvio adminModo = new ModoDeEnvio();
		D_Proveedor adminProv = new D_Proveedor();
		Insumos adminInsumo = new Insumos();
		String nombre = orden.getEmpleado().split(", ")[1];
		String apellido = orden.getEmpleado().split(", ")[0];
		int idEmpleado = adEmpleado.getIdEmpleado(nombre, apellido, tipoUsuario);
		int idEstado = adminEstado.getIdEstado(orden.getEstadoOrden());
		Proveedor prov = adminProv.getProveedorPorNombre(orden.getProveedor());
		int idModoEnvio = adminModo.getIdModoDeEnvio(orden.getModoEnvio());
		edu.server.repositorio.Empleado responsable = new edu.server.repositorio.Empleado();
		responsable.setIdEmpleado(idEmpleado);
		responsable.setApellido(apellido);
		responsable.setNombre(nombre);
		nueva.setEmpleado(responsable);
		nueva.setProveedor(prov);
		EstadoOrden eo = new EstadoOrden();
		eo.setIdEstadoOrden(idEstado);
		eo.setNombre(orden.getEstadoOrden());
		nueva.setEstadoOrden(eo);
		ModoEnvio me = new ModoEnvio();
		me.setIdModoEnvio(idModoEnvio);
		me.setDescripcion(orden.getModoEnvio());
		nueva.setModoEnvio(me);
		nueva.setIva(orden.getIva());
		nueva.setFechaEdicion(orden.getFechaEdicion());
		if (orden.getFechaGeneracion() != null) {
			nueva.setFechaGeneracion(orden.getFechaGeneracion());
		}
		nueva.setFormaPago(orden.getFormaPago());
		nueva.setTotal(orden.getTotal());
		nueva.setObservaciones(orden.getObservaciones());

		for (RenglonOrdenCompraInsumoDTO ren : orden.getRenglonOrdenCompraInsumos()) {
			RenglonOrdenCompraInsumo renglon = new RenglonOrdenCompraInsumo();
			RenglonOrdenCompraInsumoId id = new RenglonOrdenCompraInsumoId();
			id.setIdRenglonOrdenCompraInsumo(ren.getItem());
			
			
			renglon.setCantidad(ren.getCantidad());
						
			if(ren.getSubtotal() != null)
				renglon.setSubtotal(ren.getSubtotal());
			else
				renglon.setSubtotal();
			
			
			
			renglon.setId(id);
			int idInsumo = adminInsumo.getIdInsumo(ren.getInsumo().getNombre(), ren.getInsumo().getMarca());
			Insumo insu = new Insumo();
			ProveedorDeInsumo provInsumo = new ProveedorDeInsumo();
			ProveedorDeInsumoId provInsumoId = new ProveedorDeInsumoId(prov.getCodigoProveedor(), idInsumo);
			provInsumo.setId(provInsumoId);
			
			if(ren.getPrecio() != null)
				provInsumo.setPrecio(ren.getPrecio());
			else
				provInsumo.setPrecio();
			
			insu.getProveedorDeInsumos().add(provInsumo);
			insu.setIdInsumo(idInsumo);
			renglon.setInsumo(insu);
			nueva.getRenglonOrdenCompraInsumos().add(renglon);
		}

		return adminCompras.registrarOrdenCompraInsumos(nueva);
	}

	@Override
	public boolean registrarModificacionOrdenCompraInsumos(OrdenCompraInsumoDTO orden, OrdenCompraInsumoDTO ordenVieja, String tipoUsuario) throws IllegalArgumentException {
		
		boolean primerBandera = false;
		boolean segundaBandera = false;
		
		primerBandera = this.eliminarOrdenCompraInsumos(ordenVieja,tipoUsuario);
		
		segundaBandera = this.registrarOrdenCompraInsumos(orden,tipoUsuario);
		
		if(primerBandera && segundaBandera){
			return true;			
		}
		else{
			return false;
		}
			
		
	}
	
	@Override
	public boolean eliminarOrdenCompraInsumos(OrdenCompraInsumoDTO orden, String tipoUsuario) throws IllegalArgumentException {
		
		OrdenCompraInsumo nueva = new OrdenCompraInsumo();
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		D_Empleado adEmpleado = new D_Empleado();
		ModoDeEnvio adminModo = new ModoDeEnvio();
		D_Proveedor adminProv = new D_Proveedor();
		Insumos adminInsumo = new Insumos();
		String nombre = orden.getEmpleado().split(", ")[1];
		String apellido = orden.getEmpleado().split(", ")[0];
		int idEmpleado = adEmpleado.getIdEmpleado(nombre, apellido, tipoUsuario);
		int idEstado = adminEstado.getIdEstado(orden.getEstadoOrden());
		Proveedor prov = adminProv.getProveedorPorNombre(orden.getProveedor());
		int idModoEnvio = adminModo.getIdModoDeEnvio(orden.getModoEnvio());
		edu.server.repositorio.Empleado responsable = new edu.server.repositorio.Empleado();
		responsable.setIdEmpleado(idEmpleado);
		responsable.setApellido(apellido);
		responsable.setNombre(nombre);
		nueva.setEmpleado(responsable);
		nueva.setProveedor(prov);
		EstadoOrden eo = new EstadoOrden();
		eo.setIdEstadoOrden(idEstado);
		eo.setNombre(orden.getEstadoOrden());
		nueva.setEstadoOrden(eo);
		ModoEnvio me = new ModoEnvio();
		me.setIdModoEnvio(idModoEnvio);
		me.setDescripcion(orden.getModoEnvio());
		nueva.setModoEnvio(me);
		nueva.setIva(orden.getIva());
		nueva.setFechaEdicion(orden.getFechaEdicion());
		if (orden.getFechaGeneracion() != null) {
			nueva.setFechaGeneracion(orden.getFechaGeneracion());
		}
		nueva.setFormaPago(orden.getFormaPago());
		nueva.setTotal(orden.getTotal());
		nueva.setObservaciones(orden.getObservaciones());
		nueva.setNroOrdenCompraInsumo(orden.getIdOrden());

		for (RenglonOrdenCompraInsumoDTO ren : orden.getRenglonOrdenCompraInsumos()) {
			RenglonOrdenCompraInsumo renglon = new RenglonOrdenCompraInsumo();
			RenglonOrdenCompraInsumoId id = new RenglonOrdenCompraInsumoId();
			id.setIdRenglonOrdenCompraInsumo(ren.getItem());
			renglon.setCantidad(ren.getCantidad());
			renglon.setSubtotal(ren.getSubtotal());
			renglon.setId(id);
			int idInsumo = adminInsumo.getIdInsumo(ren.getInsumo().getNombre(), ren.getInsumo().getMarca());
			Insumo insu = new Insumo();
			ProveedorDeInsumo provInsumo = new ProveedorDeInsumo();
			ProveedorDeInsumoId provInsumoId = new ProveedorDeInsumoId(prov.getCodigoProveedor(), idInsumo);
			provInsumo.setId(provInsumoId);
			provInsumo.setPrecio(ren.getPrecio());
			insu.getProveedorDeInsumos().add(provInsumo);
			insu.setIdInsumo(idInsumo);
			renglon.setInsumo(insu);
			nueva.getRenglonOrdenCompraInsumos().add(renglon);
		}

		return adminCompras.eliminarOrdenCompraInsumos(nueva);
		
		
		
	}

	@Override
	public List<String> getNombreEstados() throws IllegalArgumentException {

		Estado adminE = new Estado();
		return adminE.getNombreEstados();

	}

	@Override
	public List<OrdenCompraInsumoDTO> getOrdenCompraInsumo(String estado, String prov, String fecDesde, String fecHasta) throws IllegalArgumentException {

		Administrador adminAdmin = new Administrador();
		Compras adminCompras = new Compras();
		Estado adminEstados = new Estado();
		D_Proveedor adminProv = new D_Proveedor();
		List<OrdenCompraInsumo> result = new LinkedList<OrdenCompraInsumo>();
		List<OrdenCompraInsumoDTO> listaResult = new LinkedList<OrdenCompraInsumoDTO>();

		int idEstado = adminEstados.getIdEstado(estado);
		int idProv = adminProv.getIdProveedor(prov);

		result = adminCompras.getOrdenCompraInsumo(idEstado, idProv, fecDesde, fecHasta);

		for (OrdenCompraInsumo orden : result) {
			OrdenCompraInsumoDTO ordendto = new OrdenCompraInsumoDTO();
			ordendto.setIdOrden(orden.getNroOrdenCompraInsumo());
			ordendto.setFechaEdicion(orden.getFechaEdicion());
			
			if(orden.getFechaGeneracion() != null)
				ordendto.setFechaGeneracion(orden.getFechaGeneracion());
			
			if (orden.getNroOrdenCompraInsumoGenerada() == 0) {
				ordendto.setNroOrden("S/N");
			} else {
				DecimalFormat formato = new DecimalFormat("0000000000");
				String numero = "" + formato.format(orden.getNroOrdenCompraInsumoGenerada());
				ordendto.setNroOrden(numero);
			}

			ordendto.setEmpleado(adminAdmin.getNombreEmpleado(orden.getEmpleado().getIdEmpleado()));
			ordendto.setEstadoOrden(adminEstados.getNombreEstado(orden.getEstadoOrden().getIdEstadoOrden()));
			ordendto.setProveedor(adminProv.getNombreProveedor(orden.getProveedor().getCodigoProveedor()));

			listaResult.add(ordendto);

		}
		return listaResult;

	}

	@Override
	public OrdenCompraInsumoDTO getOrdenCompraInsumoSegunId(long idOrden) throws IllegalArgumentException {

		OrdenCompraInsumoDTO orden = new OrdenCompraInsumoDTO();
		OrdenCompraInsumo ordenComun = new OrdenCompraInsumo();
		D_Proveedor adminProv = new D_Proveedor();
		Estado adminEstados = new Estado();
		Compras adminCompras = new Compras();
		Administrador adminAdmin = new Administrador();
		ModoDeEnvio adminModoDeEnvio = new ModoDeEnvio();

		orden.setIdOrden(idOrden);
		ordenComun = adminCompras.getOrdenCompraInsumoSegunId(idOrden);

		DecimalFormat formato = new DecimalFormat("0000000000");
		String numero = "" + formato.format(ordenComun.getNroOrdenCompraInsumoGenerada());
		orden.setNroOrden(numero);

		orden.setEmpleado(adminAdmin.getNombreEmpleado(ordenComun.getEmpleado().getIdEmpleado()));
		orden.setEstadoOrden(adminEstados.getNombreEstado(ordenComun.getEstadoOrden().getIdEstadoOrden()));

		orden.setProveedor(adminProv.getNombreProveedor(ordenComun.getProveedor().getCodigoProveedor()));

		orden.setModoEnvio(adminModoDeEnvio.getNombreModoEnvio(ordenComun.getModoEnvio().getIdModoEnvio()));

		orden.setFormaPago(ordenComun.getFormaPago());
		orden.setIva(ordenComun.getIva());
		orden.setTotal(ordenComun.getTotal());
		orden.setObservaciones(ordenComun.getObservaciones());
		orden.setFechaEdicion(ordenComun.getFechaEdicion());
		orden.setFechaGeneracion(ordenComun.getFechaGeneracion());

		Iterator renglones = ordenComun.getRenglonOrdenCompraInsumos().iterator();

		while (renglones.hasNext()) {

			RenglonOrdenCompraInsumoDTO renglonNuevo = new RenglonOrdenCompraInsumoDTO();
			RenglonOrdenCompraInsumo renglon = (RenglonOrdenCompraInsumo) renglones.next();

			int idRenglon = ((RenglonOrdenCompraInsumoId) renglon.getId()).getIdRenglonOrdenCompraInsumo();

			renglonNuevo.setItem(idRenglon);
			renglonNuevo.setCantidad(renglon.getCantidad());
			
			if(renglon.getSubtotal() == null)
				renglonNuevo.setSubtotal();
			else
				renglonNuevo.setSubtotal(renglon.getSubtotal());

			InsumoDTO insumo = new InsumoDTO();
			insumo = this.getInsumoCompleto(renglon.getInsumo().getIdInsumo(), "");

			renglonNuevo.setInsumo(insumo);

			int size = insumo.getProveedor().size();

			ProveedorDeInsumosDTO prov = new ProveedorDeInsumosDTO();

			for (int j = 0; j < size; j++) {

				if (insumo.getProveedor().get(j).getNombre().compareTo(orden.getProveedor()) == 0)
					prov = (ProveedorDeInsumosDTO) insumo.getProveedor().get(j);

			}

			insumo.getProveedor().clear();

			insumo.getProveedor().add(prov);

			renglonNuevo.setPrecio(insumo.getProveedor().get(0).getPrecio());

			orden.getRenglonOrdenCompraInsumos().add(renglonNuevo);

		}

		return orden;
	}

	@Override
	public boolean cancelarOrdencompraInsumo(long idOrden, String estado) throws IllegalArgumentException {
		Estado adminEstado = new Estado();
		Compras adminCompras = new Compras();
		int idEstado = adminEstado.getIdEstado(estado);
		return adminCompras.cancelarOrdenCompraInsumo(idOrden, idEstado);

	}
	
	@Override 
	public Boolean cancelarOrdenCompraInsumo(List<Long> listaOrdenes) throws IllegalArgumentException{
		
		Boolean result = true;
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("CANCELADA");
		
		for (Long nroOrden : listaOrdenes) {
			
			result = adminCompras.cancelarOrdenesComprasInsumos(nroOrden,est);
			if(result == false)
				break;
	
		}
		return result;
		
	}
	
	@Override 
	public Boolean validarOrdenCompraInsumo(List<Long> listaOrdenes) throws IllegalArgumentException{
		
		Boolean result = true;
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("VALIDADA");
		
		for (Long nroOrden : listaOrdenes) {
			
			result = adminCompras.validarOrdenesComprasInsumos(nroOrden,est);
			if(result == false)
				break;
	
		}
		return result;
		
	}
		
	@Override 
	public Boolean recibidaCompletaOrdenCompraInsumo(Long nroOrden) throws IllegalArgumentException{
		
		Boolean result = true;
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("RECIBIDA COMPLETA");
				
		result = adminCompras.recibidaCompletaOrdenCompraInsumo(nroOrden,est);
		
		return result;
		
	}
	
	@Override 
	public Boolean estadoEntregaParcialOrdenCompraInsumo(Long nroOrden) throws IllegalArgumentException{
		
		Boolean result = true;
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		int est = adminEstado.getIdEstado("RECIBIDA PARCIAL");
		
		result = adminCompras.estadoEntregaParcialOrdenCompraInsumo(nroOrden,est);
		
		return result;
		
	}
	
	@Override
 	public List<OrdenCompraInsumoDTO> getOrdenCompraInsumoGuardada(String rol, String nombreUsuario, String apellidoUsuario) throws IllegalArgumentException {

		Administrador adminAdmin = new Administrador();
		Compras adminCompras = new Compras();
		D_Proveedor adminProv = new D_Proveedor();
		D_Empleado adEmpleado = new D_Empleado();
		int idEmpleado = adEmpleado.getIdEmpleado(nombreUsuario, apellidoUsuario, rol);
		
		List<OrdenCompraInsumo> result = new LinkedList<OrdenCompraInsumo>();
		List<OrdenCompraInsumoDTO> listaResult = new LinkedList<OrdenCompraInsumoDTO>();

		result = adminCompras.getOrdenCompraInsumoGuardada(idEmpleado);

		for (OrdenCompraInsumo orden : result) {

			OrdenCompraInsumoDTO ordendto = new OrdenCompraInsumoDTO();

			ordendto.setIdOrden(orden.getNroOrdenCompraInsumo());

			ordendto.setNroOrden("S/N");

			ordendto.setEmpleado(adminAdmin.getNombreEmpleado(orden.getEmpleado().getIdEmpleado()));

			ordendto.setProveedor(adminProv.getNombreProveedor(orden.getProveedor().getCodigoProveedor()));

			listaResult.add(ordendto);

		}
		return listaResult;

	}

	@Override
	public List<OrdenCompraInsumoDTO> getOrdenCompraInsumoEnviada() throws IllegalArgumentException {

		Administrador adminAdmin = new Administrador();
		Compras adminCompras = new Compras();
		D_Proveedor adminProv = new D_Proveedor();

		List<OrdenCompraInsumo> result = new LinkedList<OrdenCompraInsumo>();
		List<OrdenCompraInsumoDTO> listaResult = new LinkedList<OrdenCompraInsumoDTO>();

		result = adminCompras.getOrdenCompraInsumoEnviada();

		for (OrdenCompraInsumo orden : result) {

			OrdenCompraInsumoDTO ordendto = new OrdenCompraInsumoDTO();

			ordendto.setIdOrden(orden.getNroOrdenCompraInsumo());

			DecimalFormat formato = new DecimalFormat("0000000000");
			String numero = "" + formato.format(orden.getNroOrdenCompraInsumoGenerada());
			ordendto.setNroOrden(numero);

			ordendto.setEmpleado(adminAdmin.getNombreEmpleado(orden.getEmpleado().getIdEmpleado()));

			ordendto.setProveedor(adminProv.getNombreProveedor(orden.getProveedor().getCodigoProveedor()));

			listaResult.add(ordendto);

		}
		return listaResult;

	}
	
	@Override
	public List<OrdenCompraInsumoDTO> getOrdenCompraInsumoEnviadaRecibidaCerrada() throws IllegalArgumentException {

		Administrador adminAdmin = new Administrador();
		Compras adminCompras = new Compras();
		D_Proveedor adminProv = new D_Proveedor();

		List<OrdenCompraInsumo> result = new LinkedList<OrdenCompraInsumo>();
		List<OrdenCompraInsumoDTO> listaResult = new LinkedList<OrdenCompraInsumoDTO>();

		result = adminCompras.getOrdenCompraInsumoEnviadaRecibidaCerrada();

		for (OrdenCompraInsumo orden : result) {

			OrdenCompraInsumoDTO ordendto = new OrdenCompraInsumoDTO();

			ordendto.setIdOrden(orden.getNroOrdenCompraInsumo());

			DecimalFormat formato = new DecimalFormat("0000000000");
			String numero = "" + formato.format(orden.getNroOrdenCompraInsumoGenerada());
			ordendto.setNroOrden(numero);

			ordendto.setEmpleado(adminAdmin.getNombreEmpleado(orden.getEmpleado().getIdEmpleado()));

			ordendto.setProveedor(adminProv.getNombreProveedor(orden.getProveedor().getCodigoProveedor()));

			listaResult.add(ordendto);

		}
		return listaResult;

	}

	@Override
	public boolean ordenDeComprasCompleta(long idOrden) throws IllegalArgumentException {
		boolean completa = true;
		List<IngresoInsumos> ingresos = new LinkedList<IngresoInsumos>();
		Almacen adminAlmacen = new Almacen();
		ingresos = adminAlmacen.getRemitosExternos(idOrden);
		Compras adminCompras = new Compras();
		OrdenCompraInsumo orden = adminCompras.getOrdenCompraInsumoSegunId(idOrden);
		List<InsumoCantidad> listado = new LinkedList<InsumoCantidad>();

		for (RenglonOrdenCompraInsumo renglon : orden.getRenglonOrdenCompraInsumos()) {
			int id = renglon.getInsumo().getIdInsumo();
			double cantidad = renglon.getCantidad();
			InsumoCantidad insumo = new InsumoCantidad();
			insumo.setCantidad(cantidad);
			insumo.setIdInsumo(id);
			listado.add(insumo);
		}
		
		for (IngresoInsumos ingreso : ingresos) {
			for(RenglonIngresoInsumos rengIngreso: ingreso.getRenglonIngresoInsumoses()){
				int idInsumo = rengIngreso.getInsumo().getIdInsumo();
				double cantIngresada = rengIngreso.getCantidadIngresada();
				for (InsumoCantidad insu : listado) {
					if(insu.getIdInsumo()== idInsumo){
						insu.setCantidad(insu.getCantidad()-cantIngresada);
					}
				}
			}
		}
		
		for (InsumoCantidad insumoCantidad : listado) {
			if(insumoCantidad.getCantidad() > 0){
				completa = false;
				break;
			}
		}

		return completa;
	}

	@Override
	public boolean actualizarOrdenCompraInsumos(OrdenCompraInsumoDTO orden) throws IllegalArgumentException {
		OrdenCompraInsumo nueva = new OrdenCompraInsumo();
		Compras adminCompras = new Compras();
		Estado adminEstado = new Estado();
		D_Empleado adEmpleado = new D_Empleado();
		ModoDeEnvio adminModo = new ModoDeEnvio();
		D_Proveedor adminProv = new D_Proveedor();
		Insumos adminInsumo = new Insumos();
		String nombre = orden.getEmpleado().split(", ")[1];
		String apellido = orden.getEmpleado().split(", ")[0];
	
		int idEmpleado = adEmpleado.getIdEmpleado(nombre, apellido, "COMPRAS");
		if (idEmpleado== -1){idEmpleado = adEmpleado.getIdEmpleado(nombre, apellido, "GERENTE DE COMPRAS");}		

		int idEstado = adminEstado.getIdEstado(orden.getEstadoOrden());
		Proveedor prov = adminProv.getProveedorPorNombre(orden.getProveedor());
		int idModoEnvio = adminModo.getIdModoDeEnvio(orden.getModoEnvio());
		edu.server.repositorio.Empleado responsable = new edu.server.repositorio.Empleado();
		responsable.setIdEmpleado(idEmpleado);
		responsable.setApellido(apellido);
		responsable.setNombre(nombre);
		nueva.setEmpleado(responsable);
		nueva.setProveedor(prov);
		nueva.setFechaCierre(orden.getFechaCierre());
		EstadoOrden eo = new EstadoOrden();
		eo.setIdEstadoOrden(idEstado);
		eo.setNombre(orden.getEstadoOrden());
		nueva.setEstadoOrden(eo);
		ModoEnvio me = new ModoEnvio();
		me.setIdModoEnvio(idModoEnvio);
		me.setDescripcion(orden.getModoEnvio());
		nueva.setModoEnvio(me);
		nueva.setIva(orden.getIva());
		nueva.setFechaEdicion(orden.getFechaEdicion());
		nueva.setNroOrdenCompraInsumo(orden.getIdOrden());
		nueva.setFormaPago(orden.getFormaPago());
		nueva.setTotal(orden.getTotal());
		nueva.setObservaciones(orden.getObservaciones());
		for (RenglonOrdenCompraInsumoDTO ren : orden.getRenglonOrdenCompraInsumos()) {
			RenglonOrdenCompraInsumo renglon = new RenglonOrdenCompraInsumo();
			RenglonOrdenCompraInsumoId id = new RenglonOrdenCompraInsumoId();
			id.setIdRenglonOrdenCompraInsumo(ren.getItem());
			id.setNroOrdenCompraInsumo(orden.getIdOrden());
			renglon.setCantidad(ren.getCantidad());
			renglon.setSubtotal(ren.getSubtotal());
			renglon.setId(id);
			int idInsumo = adminInsumo.getIdInsumo(ren.getInsumo().getNombre(), ren.getInsumo().getMarca());
			Insumo insu = new Insumo();
			ProveedorDeInsumo provInsumo = new ProveedorDeInsumo();
			ProveedorDeInsumoId provInsumoId = new ProveedorDeInsumoId(prov.getCodigoProveedor(), idInsumo);
			provInsumo.setId(provInsumoId);
			provInsumo.setPrecio(ren.getPrecio());
			insu.getProveedorDeInsumos().add(provInsumo);
			insu.setIdInsumo(idInsumo);
			renglon.setInsumo(insu);
			nueva.getRenglonOrdenCompraInsumos().add(renglon);
		}

		return adminCompras.actualizarOrdenCompraInsumos(nueva);
	}

	@Override
	public List<String> getNombresPaises() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getNombresPaises();

	}
	
	@Override
	public List<String> getNombresProvincias(String pais) throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();
		int prov = adminProv.getNroIdPais(pais);
		return adminProv.getNombresProvincias(prov);

	}
	
	@Override
	public List<String> getNombresLocalidades(String prov) throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();
		int loc = adminProv.getNroIdProvincia(prov);
		return adminProv.getNombresLocalidades(loc);

	}

	@Override
	public List<String> getMarcas() throws IllegalArgumentException {

		Insumos adminInsumos = new Insumos();

		return adminInsumos.getNombresMarcas();

	}
	
	@Override
	public List<String> getCategorias() throws IllegalArgumentException {

		Insumos adminInsumos = new Insumos();

		return adminInsumos.getNombresCategorias();

	}
	
	@Override
	public List<String> getInsumos() throws IllegalArgumentException {

		Insumos adminInsumos = new Insumos();

		return adminInsumos.getNombresInsumos();

	}
	
	@Override
	public Boolean getExistenciaCliente(String nombre) throws IllegalArgumentException {
		
		Compras adminCompras = new Compras();
		return adminCompras.getExistenciaCliente(nombre);
	}
	
	@Override
	public Boolean getExistenciaProveedor(String nombre) throws IllegalArgumentException {
		
		Compras adminCompras = new Compras();
		return adminCompras.getExistenciaProveedor(nombre);
	}

	@Override
	public List<String> getNombresCalles() throws IllegalArgumentException {

		D_Proveedor adminProv = new D_Proveedor();

		return adminProv.getNombresCalles();

	}
}
